package com.haoma.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.haoma.dto.MessageDto;
import com.haoma.entity.Message;
import com.haoma.entity.MessageDb;
import com.haoma.exception.BlogException;
import com.haoma.mapper.MessageMapper;
import com.haoma.result.Result;
import com.haoma.service.MessageService;
import com.haoma.vo.MessageListVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * Description:
 */
@Service
public class MessageServiceImpl extends ServiceImpl<MessageMapper, MessageDb> implements MessageService {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private MessageMapper messageMapper;

    /**
     * 获取所有的信息列表
     *
     * @return
     */
    public Map<String, List> getMessageList() {
        // 先将mongoDb中的留言信息获取过来
        List<Message> messageList = mongoTemplate.find(new Query()
                        .addCriteria(Criteria.where("is_deleted").is(0)) // 添加is_deleted为0的条件
                        .with(Sort.by(Sort.Direction.DESC, "createTime")), // 保持原有的按createTime降序排序
                Message.class);
        // 遍历查询所有的留言下的id 获取到名称集合和头像
        // 创建一个去重的集合
        Set<String> idList = new HashSet<>();
        // 遍历
        messageList.forEach(item -> {
            // 存储
            idList.add(item.getMessage_id());
        });
        // 统一查询
        List<MessageDb> messageDbs = messageMapper.selectBatchIds(idList);
        // 存储所有的名称集合
        Set<String> nameList = new HashSet<>();
        // 存储返回数据
        List<MessageListVo> messageVoList = new ArrayList<>();
        // 遍历所有消息
        for (Message message : messageList) {
            // 创建返回对象
            MessageListVo messageListVo = new MessageListVo();
            for (MessageDb item : messageDbs) {
                nameList.add(item.getName());
                // 判断如果mongoDb中的id如果等于数据库的id
                if (message.getMessage_id().equals(item.getId().toString())) {
                    // 存储起来
                    messageListVo.setUserUrl(item.getUserUrl());
                    messageListVo.setContent(message.getContent());
                    messageListVo.setName(item.getName());
                    messageListVo.setCreateTime(message.getCreateTime());
                    messageListVo.setUpdateTime(message.getUpdateTime());
                    messageListVo.setId(message.getMessage_id());
                }
            }
            // 存放
            messageVoList.add(messageListVo);
        }
        List<MessageDb> messageDbs1 = messageMapper.selectList(new LambdaQueryWrapper<MessageDb>().orderByDesc(MessageDb::getCreateTime));
        List<String> collect = messageDbs1.stream().map(item -> item.getName()).collect(Collectors.toList());
        Map<String, List> map = new HashMap<>();
        map.put("messageList", messageVoList);
        map.put("userList", collect);
        return map;
    }

    /**
     * 获取用户下的留言
     *
     * @param name
     * @return
     */
    public Object getMessageUser(String name) {
        //  校验
        if (name == null) {
            return Result.error("该用用户还没有留言");
        }
        // 模糊匹配
        LambdaQueryWrapper<MessageDb> messageDbLambdaQueryWrapper = new LambdaQueryWrapper<>();
        messageDbLambdaQueryWrapper.like(MessageDb::getName, name);
        // 查询数据库
        List<MessageDb> messageDbs = messageMapper.selectList(messageDbLambdaQueryWrapper);
        // 查询mongoDb所有的数据
        List<Message> messageList = mongoTemplate.find(new Query(
                        Criteria.where("isDeleted").is(0)
                ).with(Sort.by(Sort.Direction.DESC, "createTime"))
                , Message.class);
        // 存放返回对象
        List<MessageListVo> messageListVos = new ArrayList<>();
        // 遍历集合
        for (MessageDb messageDb : messageDbs) {
            for (Message message : messageList) {
                // 根据id查询到内容和时间
                if (messageDb.getId().toString().equals(message.getMessage_id())) {
                    MessageListVo messageListVo = new MessageListVo();
                    messageListVo.setId(message.getMessage_id());
                    messageListVo.setContent(message.getContent());
                    messageListVo.setCreateTime(message.getCreateTime());
                    messageListVo.setCreateTime(message.getUpdateTime());
                    messageListVo.setUserUrl(messageDb.getUserUrl());
                    messageListVo.setName(messageDb.getName());
                    messageListVos.add(messageListVo);
                }
            }
        }
        return Result.success(messageListVos);
    }


    /**
     * 根据留言名称查询
     *
     * @param content
     * @param name
     * @return
     */
    public List<MessageListVo> getMessage(String content, String name) {
        // 构建一个模糊匹配的查询
        String contentPattern = ".*" + Pattern.quote(content) + ".*"; // 使用Pattern.quote避免特殊字符影响正则表达式构建
        // 根据留言信息查询mongoDb
        Query query = new Query(new Criteria().andOperator(Criteria.where("content").regex(contentPattern, "i"),
                Criteria.where("isDeleted").is(0)));
        if (name != null) {
            // 根据name查询数据库
            LambdaQueryWrapper<MessageDb> messageDbLambdaQueryWrapper = new LambdaQueryWrapper<>();
            messageDbLambdaQueryWrapper.eq(MessageDb::getName, name);
            MessageDb messageDb = messageMapper.selectOne(messageDbLambdaQueryWrapper);
            // 如果查询不到
            if (messageDb == null) {
                // 则返回空集合
                return new ArrayList<>();
            }
            // 根据id设置条件
            query.addCriteria(Criteria.where("message_id").in(messageDb.getId().toString()));
        }
        // 查询所有
        List<Message> messageList = mongoTemplate.find(query, Message.class);
        if (CollectionUtils.isEmpty(messageList)) {
            System.out.println("为空");
            return new ArrayList<>();
        }
        // 存储id集合
        Set<String> idList = new HashSet<>();
        // 遍历留言集合
        messageList.forEach(item -> idList.add(item.getMessage_id()));
        // 查询数据库
        List<MessageDb> messageDbs = messageMapper.selectBatchIds(idList);
        // 存储返回数据
        List<MessageListVo> messageListVos = new ArrayList<>();
        // 遍历数据库
        for (MessageDb messageDb : messageDbs) {
            for (Message message : messageList) {
                if (messageDb.getId().toString().equals(message.getMessage_id())) {
                    MessageListVo messageListVo = new MessageListVo();
                    messageListVo.setId(message.getMessage_id());
                    messageListVo.setContent(message.getContent());
                    messageListVo.setCreateTime(message.getCreateTime());
                    messageListVo.setUpdateTime(message.getUpdateTime());
                    messageListVo.setUserUrl(messageDb.getUserUrl());
                    messageListVo.setName(messageDb.getName());
                    messageListVos.add(messageListVo);
                }
            }
        }
        return messageListVos;
    }

    /**
     * 根据用户名查询
     *
     * @param name
     * @return
     */
    public List<MessageListVo> getMessageByName(String name) {
        // 设置条件
        LambdaQueryWrapper<MessageDb> messageDbLambdaQueryWrapper = new LambdaQueryWrapper<>();
        messageDbLambdaQueryWrapper.eq(MessageDb::getName, name);
        MessageDb messageDb = messageMapper.selectOne(messageDbLambdaQueryWrapper);
        // 获取到信息id
        Integer id = messageDb.getId();
        // 根据id查询mongoDb
        List<Message> messageList = mongoTemplate.find(new Query(
                new Criteria().andOperator(Criteria.where("message_id").in(id.toString()),
                        Criteria.where("isDeleted").is(0))), Message.class);
        // 存储返回对象
        List<MessageListVo> messageListVos = new ArrayList<>();
        // 遍历
        for (Message message : messageList) {
            MessageListVo messageListVo = new MessageListVo();
            messageListVo.setId(message.getMessage_id());
            messageListVo.setName(messageDb.getName());
            messageListVo.setUpdateTime(message.getUpdateTime());
            messageListVo.setCreateTime(message.getCreateTime());
            messageListVo.setUserUrl(messageDb.getUserUrl());
            messageListVo.setContent(message.getContent());
            messageListVos.add(messageListVo);
        }
        return messageListVos;
    }

    /**
     * 删除留言信息
     *
     * @param id
     * @param messageDto
     */
    public void delMessage(Integer id, MessageDto messageDto) {
        // 构建查询条件
        Criteria criteria = new Criteria();
        criteria.and("message_id").is(id.toString());
        criteria.and("content").is(messageDto.getContent());
        // 创建更新条件
        Update update = new Update();
        update.set("isDeleted", 1);
        // 根据留言用户id和内容修改mongodb的字段1
        mongoTemplate.updateMulti(new Query(criteria), update, Message.class);
    }

    /**
     * 删除用户
     *
     * @param name
     */
    public void delUser(String name) {
        // 根据name查询数据库
        LambdaQueryWrapper<MessageDb> messageDbLambdaQueryWrapper = new LambdaQueryWrapper<>();
        messageDbLambdaQueryWrapper.eq(MessageDb::getName, name);
        MessageDb messageDb = messageMapper.selectOne(messageDbLambdaQueryWrapper);
        // 根据id查询mongoDb
        List<Message> messageList = mongoTemplate.find(new Query(
                new Criteria().andOperator(Criteria.where("message_id").in(messageDb.getId().toString()),
                        Criteria.where("isDeleted").is(0))), Message.class);
        if (!messageList.isEmpty()) {
            throw new BlogException("该用户下还有留言不能删除!");
        }
        // 可以删除
        messageMapper.delete(messageDbLambdaQueryWrapper);
    }
}
